using Avalonia;
using Avalonia.Controls.ApplicationLifetimes;
using Microsoft.Data.Sqlite;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
using MsBox.Avalonia.Enums;
using 畜牧业审核程序国产.Models.ToolsClass;


namespace 畜牧业审核程序国产.Models;

public class PasteToSqlite
{
    private readonly static string 填报时间取数列名 = "填报时间";
    #region 剪切板导入到数据中

    /// <summary>
    /// 把剪切板上的数据转成DataTable
    /// </summary>
    /// <param name="clipboardText"></param>
    /// <returns></returns>
    public static DataTable ConvertClipboardTextToDataTable(string clipboardText)
    {
        DataTable dataTable = new DataTable();
        try
        {
            // 以换行符分割行
            string[] rows = clipboardText.Split(new[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);

            // 处理每一行
            foreach (var row in rows)
            {
                // 以制表符分割列
                string[] columns = row.Split('\t');

                // 如果是第一行，则创建列头
                if (dataTable.Columns.Count == 0)
                {
                    foreach (var column in columns)
                    {
                        dataTable.Columns.Add(column); // 添加列名
                    }
                }
                else
                {
                    // 添加行数据
                    dataTable.Rows.Add(columns);
                }
            }

            return dataTable;
        }
        catch (System.NullReferenceException)
        {
            return null;
        }
    }

    #endregion
    /// <summary>
    /// 把根据T的类型是整形还是字符串,值是"1" 还是"一"转为"第一季度"
    /// </summary>
    /// <param name="IntSeason"></param>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    private static string ConvertIntToStringOfSeason<T>(T IntSeason)
    {
        if (IntSeason is int intvalue)
        {
            if (intvalue == 1)
            {
                return "第一季度";
            }
            else if (intvalue == 2)
            {
                return "第二季度";
            }
            else if (intvalue == 3)
            {
                return "第三季度";
            }
            else if (intvalue == 4)
            {
                return "第四季度";
            }
            else
            {
                return "输入整形参数错误";
            }
        }
        else if (IntSeason is string strValue)
        {
            if (strValue.Equals("1") || strValue.Equals("一")|| strValue.Equals("01"))
            {
                return "第一季度";
            }
            else if (strValue.Equals("2") || strValue.Equals("二") || strValue.Equals("02"))
            {
                return "第二季度";
            }
            else if (strValue.Equals("3") || strValue.Equals("三") || strValue.Equals("03"))
            {
                return "第三季度";
            }
            else if (strValue.Equals("4") || strValue.Equals("四") || strValue.Equals("04"))
            {
                return "第四季度";
            }
            else
            {
                return "输入字符串参数错误";
            }
        }
        else
        {
            return "数据类型错误";
        }
    }
    /// <summary>
    /// 根据传进来的列名,如果该列的值为空,那么DataTable中的这一行删除
    /// </summary>
    /// <param name="dataTable"></param>
    /// <param name="columnName"></param>
    public static void DeleteNullRow(DataTable dataTable, string columnName)
    {
        if (dataTable != null)
        {
            for (int i = dataTable.Rows.Count - 1; i >= 0; i--)
            {
                DataRow row = dataTable.Rows[i];
                if (row[columnName] == DBNull.Value || string.IsNullOrEmpty(row[columnName].ToString()))
                {
                    row.Delete();
                }
            }

            // 调用 AcceptChanges 方法使删除生效
            dataTable.AcceptChanges();
        }
    }
    /// <summary>
    /// 把当前剪切板的数据写入到Sqlite数据库中,返回一个FuncOutCome的对象
    /// </summary>
    /// <returns></returns>
    internal static async Task<FuncOutCome> ImportPasteToSqlite(IProgress<int> progress)
    {
        FuncOutCome pasteToSqliteOutcome = new FuncOutCome();
        DataTable dtOfPaste = null;
        try
        {
            
            if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
            //?. 运算符会首先检查 Application.Current 是否为 null。如果不为 null，就会继续访问 .ApplicationLifetime 属性；如果为 null，则整个表达式的结果为 null，而不抛出 NullReferenceException 异常。
            {
                var clipboard = desktop.MainWindow?.Clipboard;
                var clipboardText = await clipboard.GetTextAsync();

                if (clipboard != null)
                {
                    dtOfPaste = ConvertClipboardTextToDataTable(clipboardText);
                    if (dtOfPaste == null)
                    {
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.NullError;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = "没有复制数据,请重试";
                        pasteToSqliteOutcome.Icon = Icon.Error;
                        return pasteToSqliteOutcome;
                    }
                }
                else
                {
                    // await MyMessagebox.ShowAsync("没有复制数据,请重试",window);
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.NullError;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = "没有复制数据,请重试";
                    pasteToSqliteOutcome.Icon = Icon.Error;
                    return pasteToSqliteOutcome;
                }
            }

            //先判断是不是要导入的数据复制过来了
            if (dtOfPaste.Columns.Contains("年") == false || dtOfPaste.Columns.Contains("季") == false)
            {
                // await MyMessagebox.ShowAsync("数据复制错了,请重试",window);
                pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.IncongruentError;
                pasteToSqliteOutcome.FuncOutComeInfoArgs = "复制数据错误,请重新复制";
                pasteToSqliteOutcome.Icon = Icon.Error;
                return pasteToSqliteOutcome;
            }

            //获取季度和年度 
            DataRow firstRow = dtOfPaste.Rows[0];
            var yearValue = firstRow["年"].ToString();
            var seasonValue = firstRow["季"].ToString();
            string tableName = null;
            if (dtOfPaste.Columns.Contains("1;现有养猪头数-期末存栏（头）"))
            {
                tableName = "A209";
            }
            else if (dtOfPaste.Columns.Contains("1;期末存栏-肉牛（头）-能繁殖母牛"))
            {
                tableName = "A210";
            }
            else if (dtOfPaste.Columns.Contains("1;期末存栏（只）-山羊（只）-能繁殖母山羊"))
            {
                tableName = "A211";
            }
            else if (dtOfPaste.Columns.Contains("1;期末存栏（只）-肉用家禽合计（只）-肉鸡（只）"))
            {
                tableName = "A212";
            }

            else
            {
                // await MyMessagebox.ShowAsync("复制的字段错误,请重试",window);
                pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.NullError;
                pasteToSqliteOutcome.Icon = Icon.Error;
                pasteToSqliteOutcome.FuncOutComeInfoArgs = "复制的字段错误,不是四个表中的任何一个,请重新复制";
                return pasteToSqliteOutcome;
            }

            string yearAndSeason = $"统计云{yearValue}年{ConvertIntToStringOfSeason<string>(seasonValue)}";
            string withYearAndSeasonTableName = yearAndSeason + tableName;
            //MyDBOperator dBOperator = new MyDBOperator();改用单例模式
            MyDBOperator dBOperator = MyDBOperator.DBOperatorInstance;
            //把datatable的数据导入到sqlite中

            //先删掉为空的数据

            List<string> pasteColumnsNames =
                dtOfPaste.Columns.Cast<DataColumn>().Select(col => col.ColumnName).ToList();

            if (dtOfPaste != null)
            {
                DeleteNullRow(dtOfPaste, 填报时间取数列名);//这里可能要调整,报出日期改成了填报时间
            }

            //  dBOperator.ResetOnlyColumnNamesTable(withYearAndSeasonTableName);//这句要放到后面去,不然有列没行数据,报错
            int totalRows = dtOfPaste.Rows.Count;
            int processedRows = 0;
            int percentage = 0;
            using (SqliteConnection sqliteCon = new SqliteConnection($"Data Source={MyDBOperator._dbPath}"))
            {
                sqliteCon.Open();

                if (withYearAndSeasonTableName.Contains("A209"))
                {
                    string[] DBNeedcolumnNames =
                    [
                        "处理地编码",
                    "处理地名称",
                    "养殖场（户）编码：",
                    "养殖场（户）名称：",
                    "填报时间",
                    "年",
                    "季",
                    "省（区、市）",
                    "市（地、州、盟）",
                    "调查村地址（县）",
                    "乡村",
                    "调查村地址（村）",
                    "调查村编码",
                    "养殖户（单位）类型",
                    "1;现有养猪头数-期末存栏（头）",
                    "1;现有养猪头数-期末存栏（头）-25公斤以下仔猪",
                    "1;现有养猪头数-期末存栏（头）-待育肥猪",
                    "1;现有养猪头数-期末存栏（头）-待育肥猪-50公斤以上",
                    "1;现有养猪头数-期末存栏（头）-种猪",
                    "1;现有养猪头数-期末存栏（头）-种猪-能繁殖母猪",
                    "1;期内增加数量（头）",
                    "1;期内增加数量（头）-自繁",
                    "1;期内增加数量（头）-购进",
                    "1;期内减少数量（头）",
                    "1;期内减少数量（头）-自宰肥猪数量（头）",
                    "1;期内减少数量（头）-出售肥猪-数量（头）",
                    "1;期内减少数量（头）-出售肥猪-金额（元）",
                    "1;期内减少数量（头）-出售肥猪-重量（公斤）",
                    "1;期内减少数量（头）-其他原因减少数量（头）",
                    "1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-数量（头）",
                    "1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-金额（元）",
                    "1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-重量（公斤）",
                    "单位负责人",
                    "填表人",
                    "报出日期"
                    ];
                    var pasteLostColumnsNames = DBNeedcolumnNames.Except(pasteColumnsNames); //找出数据库里要有,但是excel里没有的字段
                    if (pasteLostColumnsNames.Count() > 0)
                    {
                        string StrPasteLostColumnsNames = null;
                        foreach (var item in pasteLostColumnsNames)
                        {
                            StrPasteLostColumnsNames += $"“{item.ToString()}”、";
                        }

                        // await MyMessagebox.ShowAsync($"{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}缺失,请重新从平台下载数据后再次导入!",window);
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.NullError;
                        pasteToSqliteOutcome.Icon = Icon.Error;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = $"剪切板上复制过来的数据有字段缺失,缺失字段为{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}";
                        return pasteToSqliteOutcome;
                    }
                    dBOperator.ResetOnlyColumnNamesTable(withYearAndSeasonTableName);
                    //SetDBnullToStrZero(dtInXlsFile);
                    try
                    {
                        foreach (DataRow Row in dtOfPaste.Rows)
                        {
                            for (int i = 0; i < dtOfPaste.Columns.Count; i++)
                            {
                                if (Row.IsNull(i) || string.IsNullOrWhiteSpace(Row[i].ToString()))
                                {
                                    Row[i] = "0";
                                }
                            }


                            string insetSql =
                                    //$"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,养殖户单位类型,村,单位负责人,填表人,报出日期年," +
                                    //$"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,[期末存栏合计01],[25公斤以下仔猪02]," +
                                    //$"[待育肥猪03],[50公斤以上04],[种猪05],[能繁殖母猪06],[当季增加头数07],[自繁08],[购进09],[当季减少头数10],[自宰肥猪头数11]," +
                                    //$"[出售肥猪头数（不包括出售待育肥猪）12],[出售肥猪金额13],[出售肥猪重量14],[其它原因减少（包括死亡、疫病捕杀）15], " +
                                    //$"[出售25公斤以下仔猪头数16],[出售25公斤以下仔猪金额17],[出售25公斤以下仔猪重量18]) " +
                                    $"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,养殖户单位类型,村,单位负责人,填表人,报出日期年," +
                                    $"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,[期末存栏合计01],[25公斤以下仔猪存栏数02]," +
                                    $"[待育肥猪存栏数03],[50公斤以上待育肥猪存栏数04],[种猪存栏数05],[能繁殖母猪存栏数06],[当季增加头数07],[自繁头数08],[购进头数09],[当季减少头数10],[自宰肥猪头数11]," +
                                    $"[出售肥猪头数（不包括出售待育肥猪）12],[出售肥猪金额（元）13],[出售肥猪重量（公斤）14],[其它原因减少（包括死亡、疫病捕杀）15], " +
                                    $"[出售25公斤以下仔猪头数16],[出售25公斤以下仔猪金额（元）17],[出售25公斤以下仔猪重量（公斤）18]) " +
                                $"values('{Row["调查村编码"].ToString()}', '{(string)Row["调查村编码"]}', '{Row["养殖户（单位）类型"].ToString()}','{Row["调查村地址（村）"]}','{Row["单位负责人"]}','{Row["填表人"]}'" +
                                $",'{Row["年"]}','{Row[$"{填报时间取数列名}"].ToString().Substring(5, 2)}','{Row[$"{填报时间取数列名}"].ToString().Substring(8, 2)}','{Row["省（区、市）"]}','{Row["市（地、州、盟）"]}','{Row["调查村地址（县）"]}','{Row["乡村"]}'," +
                                $"'{Row["年"]}','{Row["季"]}','{Row["养殖场（户）编码："]}','{Row["养殖场（户）名称："]}','{Row["1;现有养猪头数-期末存栏（头）"]}','{Row["1;现有养猪头数-期末存栏（头）-25公斤以下仔猪"]}'," +
                                $"'{Row["1;现有养猪头数-期末存栏（头）-待育肥猪"]}','{Row["1;现有养猪头数-期末存栏（头）-待育肥猪-50公斤以上"]}','{Row["1;现有养猪头数-期末存栏（头）-种猪"]}','{Row["1;现有养猪头数-期末存栏（头）-种猪-能繁殖母猪"]}'," +
                                $"'{Row["1;期内增加数量（头）"]}','{Row["1;期内增加数量（头）-自繁"]}','{Row["1;期内增加数量（头）-购进"]}','{Row["1;期内减少数量（头）"]}','{Row["1;期内减少数量（头）-自宰肥猪数量（头）"]}'," +
                                $"'{Row["1;期内减少数量（头）-出售肥猪-数量（头）"]}','{Row["1;期内减少数量（头）-出售肥猪-金额（元）"]}','{Row["1;期内减少数量（头）-出售肥猪-重量（公斤）"]}','{Row["1;期内减少数量（头）-其他原因减少数量（头）"]}','{Row["1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-数量（头）"]}'," +
                                $"'{Row["1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-金额（元）"]}','{Row["1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-重量（公斤）"]}' )";


                            using (SqliteCommand insertCommand = new SqliteCommand(insetSql, sqliteCon))
                            {
                                insertCommand.ExecuteNonQuery();
                            }
                            processedRows++;
                            percentage = (int)((double)processedRows / totalRows * 100);
                            progress.Report(percentage);
                        }

                        dBOperator.AddImportTime(sqliteCon, withYearAndSeasonTableName);
                        //增加字段
                        List<string> sqlToAddColumns = new List<string>() {

                        $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 当季出栏数 DOUBLE",
                        $"UPDATE {withYearAndSeasonTableName} SET 当季出栏数 = [自宰肥猪头数11] + [出售肥猪头数（不包括出售待育肥猪）12]",
                        $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 乡镇代码 STRING",
                        $"UPDATE {withYearAndSeasonTableName} SET 乡镇代码 = substr(户编码,1,9)",
                        $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 县代码 STRING",
                        $"UPDATE {withYearAndSeasonTableName} SET 县代码 = substr(户编码,1,6)",
                        $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 市代码 STRING",
                        $"UPDATE {withYearAndSeasonTableName} SET 市代码 = substr(户编码,1,4)",
                        $"alter table {withYearAndSeasonTableName} add column 数据处理县代码 string",
                        $"UPDATE {withYearAndSeasonTableName} SET 数据处理县代码 = substr(数据处理地,1,6)",
                    };

                        for (int i = 0; i < sqlToAddColumns.Count; i++)
                        {
                            dBOperator.ExecuteBySql(sqlToAddColumns[i]);
                        }
                    }
                    catch (Exception ex)
                    {
                        percentage = 100;
                        progress.Report(percentage);
                        StaticLogger.SystemError($"粘贴出错,出错的表为{withYearAndSeasonTableName}错误信息为{ex.Message}");
                        StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = $"{withYearAndSeasonTableName}表错误,原因是{ex.Message}";
                        return pasteToSqliteOutcome;
                    }
                }
                else if (withYearAndSeasonTableName.Contains("A210"))
                {
                    string[] DBNeedcolumnNames =
                    [
                        "处理地编码",
                    "处理地名称",
                    "养殖场（户）编码：",
                    "养殖场（户）名称：",
                    "填报时间",
                    "年",
                    "季",
                    "省",
                    "市（地、州、盟）",
                    "县",
                    "乡（镇）",
                    "调查村地址（村）",
                    "调查村编码",
                    "养殖户（单位）类型",
                    "1;期末存栏",
                    "1;期末存栏-肉牛（头）",
                    "1;期末存栏-肉牛（头）-能繁殖母牛",
                    "1;期末存栏-奶牛（头）",
                    "1;期末存栏-奶牛（头）-在产专用奶牛（头）",
                    "1;期内增加数量（头）",
                    "1;期内增加数量（头）-自繁（头）",
                    "1;期内增加数量（头）-自繁（头）-肉牛（头）",
                    "1;期内增加数量（头）-自繁（头）-奶牛（头）",
                    "1;期内增加数量（头）-购进（头）",
                    "1;期内增加数量（头）-购进（头）-肉牛（头）",
                    "1;期内增加数量（头）-购进（头）-奶牛（头）",
                    "1;期内减少数量（头）",
                    "1;期内减少数量（头）-自宰肉牛（头）",
                    "1;期内减少数量（头）-出售肉牛-数量（头）",
                    "1;期内减少数量（头）-出售肉牛-金额（元）",
                    "1;期内减少数量（头）-出售肉牛-重量（公斤）",
                    "1;期内减少数量（头）-生牛奶产量（公斤）",
                    "单位负责人",
                    "填表人",
                    "报出日期"
                    ];
                    var pasteLostColumnsNames = DBNeedcolumnNames.Except(pasteColumnsNames); //找出数据库里要有,但是excel里没有的字段
                    if (pasteLostColumnsNames.Count() > 0)
                    {
                        string StrPasteLostColumnsNames = null;
                        foreach (var item in pasteLostColumnsNames)
                        {
                            StrPasteLostColumnsNames += $"“{item.ToString()}”、";
                        }

                        //await MyMessagebox.ShowAsync(
                        //    $"{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}缺失,请重新从平台下载数据后再次导入!",window);
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.FieldMissingError;
                        pasteToSqliteOutcome.Icon = Icon.Error;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = $"剪切板上复制过来的数据有字段缺失,缺失字段为{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}";
                        return pasteToSqliteOutcome;

                    }
                    dBOperator.ResetOnlyColumnNamesTable(withYearAndSeasonTableName);
                    try
                    {
                        foreach (DataRow Row in dtOfPaste.Rows)
                        {
                            for (int i = 0; i < dtOfPaste.Columns.Count; i++)
                            {
                                if (Row.IsNull(i) || string.IsNullOrWhiteSpace(Row[i].ToString()))
                                {
                                    Row[i] = "0";
                                }
                            }

                            string insetSql =
                                    //$"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                    //$"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏头数01],[肉牛02]," +
                                    //$"[能繁殖母牛03],[奶牛04],[在产奶牛05],[当季增加头数06],[自繁07],[肉牛08],[奶牛09],[购进10],[肉牛11]," +
                                    //$"[奶牛12],[期内减少头数13],[自宰肉牛数量14],[出售肉牛数量15], " +
                                    //$"[出售肉牛金额16],[出售肉牛重量17],[当季生牛奶产量18]) " +
                                    $"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                    $"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏头数01],[肉牛存栏数02]," +
                                    $"[能繁殖母牛存栏数03],[奶牛存栏数04],[在产奶牛存栏数05],[当季增加头数06],[自繁头数07],[自繁肉牛头数08],[自繁奶牛头数09],[购进头数10],[购进肉牛头数11]," +
                                    $"[购进奶牛头数12],[期内减少头数13],[自宰肉牛数量14],[出售肉牛数量15], " +
                                    $"[出售肉牛金额（元）16],[出售肉牛重量（公斤）17],[当季生牛奶产量（公斤）18]) " +
                                $"values('{Row["调查村编码"].ToString()}', '{(string)Row["调查村编码"]}','{Row["调查村地址（村）"]}','{Row["单位负责人"]}','{Row["填表人"]}'" +
                                $",'{Row["年"]}','{Row[$"{填报时间取数列名}"].ToString().Substring(5, 2)}','{Row[$"{填报时间取数列名}"].ToString().Substring(8, 2)}','{Row["省"]}','{Row["市（地、州、盟）"]}','{Row["县"]}','{Row["乡（镇）"]}'," +
                                $"'{Row["年"]}','{Row["季"]}','{Row["养殖场（户）编码："]}','{Row["养殖场（户）名称："]}','{Row["养殖户（单位）类型"]}','{Row["1;期末存栏"]}','{Row["1;期末存栏-肉牛（头）"]}'," +
                                $"'{Row["1;期末存栏-肉牛（头）-能繁殖母牛"]}','{Row["1;期末存栏-奶牛（头）"]}','{Row["1;期末存栏-奶牛（头）-在产专用奶牛（头）"]}','{Row["1;期内增加数量（头）"]}'," +
                                $"'{Row["1;期内增加数量（头）-自繁（头）"]}','{Row["1;期内增加数量（头）-自繁（头）-肉牛（头）"]}','{Row["1;期内增加数量（头）-自繁（头）-奶牛（头）"]}','{Row["1;期内增加数量（头）-购进（头）"]}','{Row["1;期内增加数量（头）-购进（头）-肉牛（头）"]}'," +
                                $"'{Row["1;期内增加数量（头）-购进（头）-奶牛（头）"]}','{Row["1;期内减少数量（头）"]}','{Row["1;期内减少数量（头）-自宰肉牛（头）"]}','{Row["1;期内减少数量（头）-出售肉牛-数量（头）"]}','{Row["1;期内减少数量（头）-出售肉牛-金额（元）"]}'," +
                                $"'{Row["1;期内减少数量（头）-出售肉牛-重量（公斤）"]}','{Row["1;期内减少数量（头）-生牛奶产量（公斤）"]}' )";
                            using (SqliteCommand insertCommand = new SqliteCommand(insetSql, sqliteCon))
                            {
                                insertCommand.ExecuteNonQuery();
                            }
                            processedRows++;
                            percentage = (int)((double)processedRows / totalRows * 100);
                            progress.Report(percentage);
                        }

                        dBOperator.AddImportTime(sqliteCon, withYearAndSeasonTableName);
                        List<string> ListSqlToAddColumns =
                        [
                            $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 当季出栏数 DOUBLE",
                        $"UPDATE {withYearAndSeasonTableName} SET 当季出栏数 = [自宰肉牛数量14] + [出售肉牛数量15]",
                        $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 乡镇代码 STRING",
                        $"UPDATE {withYearAndSeasonTableName} SET 乡镇代码 = substr(户编码,1,9)",
                        $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 县代码 STRING",
                        $"UPDATE {withYearAndSeasonTableName} SET 县代码 = substr(户编码,1,6)",
                        $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 市代码 STRING",
                        $"UPDATE {withYearAndSeasonTableName} SET 市代码 = substr(户编码,1,4)",
                        $"alter table {withYearAndSeasonTableName} add column 数据处理县代码 string",
                        $"UPDATE {withYearAndSeasonTableName} SET 数据处理县代码 = substr(数据处理地,1,6)",
                    ];
                        for (int i = 0; i < ListSqlToAddColumns.Count; i++)
                        {
                            dBOperator.ExecuteBySql(ListSqlToAddColumns[i]);
                        }
                    }
                    catch (Exception ex)
                    {
                        percentage = 100;
                        progress.Report(percentage);
                        StaticLogger.SystemError($"粘贴出错,出错的表为{withYearAndSeasonTableName}错误信息为{ex.Message}");
                        StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = $"{withYearAndSeasonTableName}表错误,原因是{ex.Message}";
                        return pasteToSqliteOutcome;
                    }
                }
                else if (withYearAndSeasonTableName.Contains("A211"))
                {
                    string[] DBNeedcolumnNames =
                    [
                        "处理地编码",
                    "处理地名称",
                    "养殖场（户）编码：",
                    "养殖场（户）名称：",
                    "填报时间",
                    "年",
                    "季",
                    "省（区、市）",
                    "市（地、州、盟）",
                    "县（区、市）",
                    "乡（镇）",
                    "调查村地址（村）",
                    "调查村编码",
                    "养殖户（单位）类型",
                    "1;期末存栏（只）",
                    "1;期末存栏（只）-山羊（只）",
                    "1;期末存栏（只）-山羊（只）-能繁殖母山羊",
                    "1;期末存栏（只）-绵羊（只）",
                    "1;期末存栏（只）-绵羊（只）-能繁殖母绵羊",
                    "1;期内增加数量（只）",
                    "1;期内增加数量（只）-自繁（只）",
                    "1;期内增加数量（只）-自繁（只）-山羊（只）",
                    "1;期内增加数量（只）-自繁（只）-绵羊（只）",
                    "1;期内增加数量（只）-购进（只）",
                    "1;期内增加数量（只）-购进（只）-山羊（只）",
                    "1;期内增加数量（只）-购进（只）-绵羊（只）",
                    "1;期内减少数量（只）",
                    "1;期内减少数量（只）-自宰羊数量（只）",
                    "1;期内减少数量（只）-出售羊-数量（只）",
                    "1;期内减少数量（只）-出售羊-金额（元）",
                    "1;期内减少数量（只）-出售羊-重量（公斤）",
                    "1;绵羊毛产量（公斤）",
                    "1;山羊绒产量（公斤）",
                    "单位负责人",
                    "填表人",
                    "报出日期"
                    ];
                    var pasteLostColumnsNames = DBNeedcolumnNames.Except(pasteColumnsNames); //找出数据库里要有,但是excel里没有的字段
                    if (pasteLostColumnsNames.Count() > 0)
                    {
                        string StrPasteLostColumnsNames = null;
                        foreach (var item in pasteLostColumnsNames)
                        {
                            StrPasteLostColumnsNames += $"“{item.ToString()}”、";
                        }

                        //await MyMessagebox.ShowAsync(
                        //    $"{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}缺失,请重新从平台下载数据后再次导入!",window);
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.FieldMissingError;
                        pasteToSqliteOutcome.Icon = Icon.Error;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = $"剪切板上复制过来的数据有字段缺失,缺失的字段为{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}";
                        return pasteToSqliteOutcome;
                    }

                    dBOperator.ResetOnlyColumnNamesTable(withYearAndSeasonTableName);
                    try
                    {
                        foreach (DataRow Row in dtOfPaste.Rows)
                        {
                            for (int i = 0; i < dtOfPaste.Columns.Count; i++)
                            {
                                if (Row.IsNull(i) || string.IsNullOrWhiteSpace(Row[i].ToString()))
                                {
                                    Row[i] = "0";
                                }
                            }

                            string insetSql =
                                    //$"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                    //$"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏只数01],[山   羊02]," +
                                    //$"[能繁殖母山羊03],[绵(湖)羊04],[能繁殖母绵羊05],[期内增加只数06],[自繁07],[山   羊08],[绵(湖)羊09],[购进10],[山   羊11]," +
                                    //$"[绵(湖)羊12],[期内减少只数13],[自宰羊数量14],[出售羊数量15], " +
                                    //$"[出售羊金额16],[出售羊重量17],[当季绵羊毛产量18],[当季山羊绒产量19]) " +
                                    $"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                    $"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏只数01],[山羊存栏只数02]," +
                                    $"[能繁殖母山羊存栏只数03],[绵(湖)羊存栏只数04],[能繁殖母绵羊存栏只数05],[期内增加只数06],[自繁只数07],[山羊自繁只数08],[绵(湖)羊自繁只数09],[购进只数10],[山羊购进只数11]," +
                                    $"[绵(湖)羊购进只数12],[期内减少只数13],[自宰羊数量14],[出售羊数量15], " +
                                    $"[出售羊金额（元）16],[出售羊重量（公斤）17],[当季绵羊毛产量（公斤）18],[当季山羊绒产量（公斤）19]) " +
                                $"values('{Row["调查村编码"].ToString()}', '{(string)Row["调查村编码"]}','{Row["调查村地址（村）"]}','{Row["单位负责人"]}','{Row["填表人"]}'" +
                                $",'{Row["年"]}','{Row[$"{填报时间取数列名}"].ToString().Substring(5, 2)}','{Row[$"{填报时间取数列名}"].ToString().Substring(8, 2)}','{Row["省（区、市）"]}','{Row["市（地、州、盟）"]}','{Row["县（区、市）"]}','{Row["乡（镇）"]}'," +
                                $"'{Row["年"]}','{Row["季"]}','{Row["养殖场（户）编码："]}','{Row["养殖场（户）名称："]}','{Row["养殖户（单位）类型"]}','{Row["1;期末存栏（只）"]}','{Row["1;期末存栏（只）-山羊（只）"]}'," +
                                $"'{Row["1;期末存栏（只）-山羊（只）-能繁殖母山羊"]}','{Row["1;期末存栏（只）-绵羊（只）"]}','{Row["1;期末存栏（只）-绵羊（只）-能繁殖母绵羊"]}','{Row["1;期内增加数量（只）"]}'," +
                                $"'{Row["1;期内增加数量（只）-自繁（只）"]}','{Row["1;期内增加数量（只）-自繁（只）-山羊（只）"]}','{Row["1;期内增加数量（只）-自繁（只）-绵羊（只）"]}','{Row["1;期内增加数量（只）-购进（只）"]}','{Row["1;期内增加数量（只）-购进（只）-山羊（只）"]}'," +
                                $"'{Row["1;期内增加数量（只）-购进（只）-绵羊（只）"]}','{Row["1;期内减少数量（只）"]}','{Row["1;期内减少数量（只）-自宰羊数量（只）"]}','{Row["1;期内减少数量（只）-出售羊-数量（只）"]}','{Row["1;期内减少数量（只）-出售羊-金额（元）"]}'," +
                                $"'{Row["1;期内减少数量（只）-出售羊-重量（公斤）"]}','{Row["1;绵羊毛产量（公斤）"]}','{Row["1;山羊绒产量（公斤）"]}' )";
                            using (SqliteCommand insertCommand = new SqliteCommand(insetSql, sqliteCon))
                            {
                                insertCommand.ExecuteNonQuery();
                            }
                            processedRows++;
                            percentage = (int)((double)processedRows / totalRows * 100);
                            progress.Report(percentage);
                        }

                        dBOperator.AddImportTime(sqliteCon, withYearAndSeasonTableName);
                        List<string> ListSqlToAddColumns = new List<string>();
                        ListSqlToAddColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 当季出栏数 DOUBLE");
                        ListSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季出栏数 = [自宰羊数量14] + [出售羊数量15]");
                        ListSqlToAddColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 乡镇代码 STRING");
                        ListSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 乡镇代码 = substr(户编码,1,9)");
                        ListSqlToAddColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 县代码 STRING");
                        ListSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 县代码 = substr(户编码,1,6)");
                        ListSqlToAddColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 市代码 STRING");
                        ListSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 市代码 = substr(户编码,1,4)");
                        ListSqlToAddColumns.Add($"alter table {withYearAndSeasonTableName} add column 数据处理县代码 string");
                        ListSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 数据处理县代码 = substr(数据处理地,1,6)");
                        for (int i = 0; i < ListSqlToAddColumns.Count; i++)
                        {
                            dBOperator.ExecuteBySql(ListSqlToAddColumns[i]);
                        }
                    }
                    catch (Exception ex)
                    {
                        percentage = 100;
                        progress.Report(percentage);
                        StaticLogger.SystemError($"粘贴出错,出错的表为{withYearAndSeasonTableName}错误信息为{ex.Message}");
                        StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = $"{withYearAndSeasonTableName}表错误,原因是{ex.Message}";
                        return pasteToSqliteOutcome;
                    }
                }
                else if (withYearAndSeasonTableName.Contains("A212"))
                {
                    string[] DBNeedcolumnNames =
                    [
                        "处理地编码",
                    "处理地名称",
                    "养殖场（户）编码：",
                    "养殖场（户）名称：",
                    "填报时间",
                    "年",
                    "季",
                    "省（区、市）",
                    "市（地、州、盟）",
                    "县（区、市）",
                    "乡（镇）",
                    "调查村地址（村）",
                    "调查村编码",
                    "养殖户（单位）类型",
                    "1;期末存栏（只）",
                    "1;期末存栏（只）-肉用家禽合计（只）",
                    "1;期末存栏（只）-肉用家禽合计（只）-肉鸡（只）",
                    "1;期末存栏（只）-蛋用家禽合计（只）",
                    "1;期末存栏（只）-蛋用家禽合计（只）-蛋鸡（只）",
                    "1;期内减少数量（只）",
                    "1;期内减少数量（只）-自宰家禽数量（只）",
                    "1;期内减少数量（只）-自宰家禽数量（只）-活鸡（只）",
                    "1;期内减少数量（只）-出售家禽-数量（只）",
                    "1;期内减少数量（只）-出售家禽-数量（只）-活鸡（只）",
                    "1;期内减少数量（只）-出售家禽-金额（元）",
                    "1;期内减少数量（只）-出售家禽-金额（元）-活鸡（元）",
                    "1;期内减少数量（只）-出售家禽-重量（公斤）",
                    "1;期内减少数量（只）-出售家禽-重量（公斤）-活鸡（公斤）",
                    "1;禽蛋数量（公斤）",
                    "1;禽蛋数量（公斤）-鸡蛋（公斤）",
                    "单位负责人",
                    "填表人",
                    "报出日期"
                    ];


                    var pasteLostColumnsNames = DBNeedcolumnNames.Except(pasteColumnsNames); //找出数据库里要有,但是excel里没有的字段
                    if (pasteLostColumnsNames.Count() > 0)
                    {
                        string StrPasteLostColumnsNames = null;
                        foreach (var item in pasteLostColumnsNames)
                        {
                            StrPasteLostColumnsNames += $"“{item.ToString()}”、";
                        }

                        //await MyMessagebox.ShowAsync(
                        //    $"{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}缺失,请重新从平台下载数据后再次导入!",window);
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.FieldMissingError;
                        pasteToSqliteOutcome.Icon = Icon.Error;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = $"剪切板上复制过来的数据有字段缺失,缺失的字段为{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}";
                        return pasteToSqliteOutcome;
                    }

                    dBOperator.ResetOnlyColumnNamesTable(withYearAndSeasonTableName);
                    try
                    {
                        foreach (DataRow Row in dtOfPaste.Rows)
                        {
                            for (int i = 0; i < dtOfPaste.Columns.Count; i++)
                            {
                                if (Row.IsNull(i) || string.IsNullOrWhiteSpace(Row[i].ToString()))
                                {
                                    Row[i] = "0";
                                }
                            }

                            string insetSql =
                                    //$"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                    //$"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏只数01],[肉用02]," +
                                    //$"[肉鸡03],[蛋用04],[蛋鸡05],[期内减少只数06],[自宰家禽数量07],[活鸡08],[出售家禽数量09],[活鸡10],[出售家禽金额11]," +
                                    //$"[活鸡12],[出售家禽重量13],[活鸡14],[当季禽蛋产量15], [鸡蛋16]) " +
                                    $"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                    $"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏只数01],[肉用家禽存栏只数02]," +
                                    $"[肉鸡存栏只数03],[蛋用家禽存栏只数04],[蛋鸡存栏只数05],[期内减少只数06],[自宰家禽数量07],[自宰活鸡数量08],[出售家禽数量09],[出售活鸡数量10],[出售家禽金额（元）11]," +
                                    $"[出售活鸡金额（元）12],[出售家禽重量（公斤）13],[出售活鸡重量（公斤）14],[当季禽蛋产量（公斤）15], [鸡蛋产量（公斤）16]) " +
                                $"values('{Row["调查村编码"].ToString()}', '{(string)Row["调查村编码"]}','{Row["调查村地址（村）"]}','{Row["单位负责人"]}','{Row["填表人"]}'" +
                                $",'{Row["年"]}','{Row[$"{填报时间取数列名}"].ToString().Substring(5, 2)}','{Row[$"{填报时间取数列名}"].ToString().Substring(8, 2)}','{Row["省（区、市）"]}','{Row["市（地、州、盟）"]}','{Row["县（区、市）"]}','{Row["乡（镇）"]}'," +
                                $"'{Row["年"]}','{Row["季"]}','{Row["养殖场（户）编码："]}','{Row["养殖场（户）名称："]}','{Row["养殖户（单位）类型"]}','{Row["1;期末存栏（只）"]}','{Row["1;期末存栏（只）-肉用家禽合计（只）"]}'," +
                                $"'{Row["1;期末存栏（只）-肉用家禽合计（只）-肉鸡（只）"]}','{Row["1;期末存栏（只）-蛋用家禽合计（只）"]}','{Row["1;期末存栏（只）-蛋用家禽合计（只）-蛋鸡（只）"]}','{Row["1;期内减少数量（只）"]}'," +
                                $"'{Row["1;期内减少数量（只）-自宰家禽数量（只）"]}','{Row["1;期内减少数量（只）-自宰家禽数量（只）-活鸡（只）"]}','{Row["1;期内减少数量（只）-出售家禽-数量（只）"]}','{Row["1;期内减少数量（只）-出售家禽-数量（只）-活鸡（只）"]}','{Row["1;期内减少数量（只）-出售家禽-金额（元）"]}'," +
                                $"'{Row["1;期内减少数量（只）-出售家禽-金额（元）-活鸡（元）"]}','{Row["1;期内减少数量（只）-出售家禽-重量（公斤）"]}','{Row["1;期内减少数量（只）-出售家禽-重量（公斤）-活鸡（公斤）"]}','{Row["1;禽蛋数量（公斤）"]}','{Row["1;禽蛋数量（公斤）-鸡蛋（公斤）"]}'" +
                                $" )";
                            using (SqliteCommand insertCommand = new SqliteCommand(insetSql, sqliteCon))
                            {
                                insertCommand.ExecuteNonQuery();
                            }
                            processedRows++;
                            percentage = (int)((double)processedRows / totalRows * 100);
                            progress.Report(percentage);
                        }

                        dBOperator.AddImportTime(sqliteCon, withYearAndSeasonTableName);
                        List<string> listSqlToAddColumns = new List<string>();
                        listSqlToAddColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 当季家禽出栏数 DOUBLE");
                        listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季家禽出栏数 = [自宰家禽数量07] + [出售家禽数量09]");
                        listSqlToAddColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 当季鸡出栏数 DOUBLE");
                        //listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季鸡出栏数 = [活鸡08] + [活鸡10]");
                        listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季鸡出栏数 = [自宰活鸡数量08] + [出售活鸡数量10]");
                        listSqlToAddColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 乡镇代码 STRING");
                        listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 乡镇代码 = substr(户编码,1,9)");
                        listSqlToAddColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 县代码 STRING");
                        listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 县代码 = substr(户编码,1,6)");
                        listSqlToAddColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 市代码 STRING");
                        listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 市代码 = substr(户编码,1,4)");
                        listSqlToAddColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 当季鸡存栏数 double");
                        // listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季鸡存栏数 = [肉鸡03]+[蛋鸡05]");
                        listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季鸡存栏数 = [肉鸡存栏只数03]+[蛋鸡存栏只数05]");
                        listSqlToAddColumns.Add($"alter table {withYearAndSeasonTableName} add column 数据处理县代码 string");
                        listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 数据处理县代码 = substr(数据处理地,1,6)");
                        for (int i = 0; i < listSqlToAddColumns.Count; i++)
                        {
                            dBOperator.ExecuteBySql(listSqlToAddColumns[i]);
                        }
                    }
                    catch (Exception ex)
                    {
                        percentage = 100;
                        progress.Report(percentage);
                        StaticLogger.SystemError($"粘贴出错,出错的表为{withYearAndSeasonTableName}错误信息为{ex.Message}");
                        StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = $"{withYearAndSeasonTableName}表错误,原因是{ex.Message}";
                        return pasteToSqliteOutcome;
                    }
                }
                else if (withYearAndSeasonTableName.Contains("A406"))
                {
                    string[] DBNeedcolumnNames = new string[]
                    {
                        "组织机构代码", "数据处理地", "综合机关名称", "期别(年)", "期别(季)", "单位负责人", "填表人", "报出日期(年)", "报出日期(月)", "报出日期(日)",
                        "数量;存栏头数（含未断奶小猪）", "数量;其中：能繁殖的母猪", "数量;生猪出栏头数", "数量;存栏头数", "数量;其中：良种及改良种乳牛", "数量;出栏头数",
                        "数量;存栏只数", "数量;出栏只数", "数量;存栏只数_1", "数量;出栏只数_1", "数量;存栏只数_2", "数量;出栏只数_2", "数量;肉类产量",
                        "数量;肉类产量;（省增）猪肉",
                        "数量;肉类产量;牛肉", "数量;肉类产量;羊肉", "数量;肉类产量;禽肉", "数量;肉类产量;兔肉", "数量;肉类产量;其他", "数量;鸡鸭鹅蛋产量",
                        "数量;生牛奶产量_33",
                        "数量;蚕茧产量", "数量;其中：鸡存栏", "数量;其中：鸡出栏"
                    };

                    var pasteLostColumnsNames = DBNeedcolumnNames.Except(pasteColumnsNames); //找出数据库里要有,但是excel里没有的字段
                    if (pasteLostColumnsNames.Count() > 0)
                    {
                        string StrPasteLostColumnsNames = null;
                        foreach (var item in pasteLostColumnsNames)
                        {
                            StrPasteLostColumnsNames += $"“{item.ToString()}”、";
                        }

                        //await MyMessagebox.ShowAsync(
                        //    $"{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}缺失,请重新从平台下载数据后再次导入!",window);
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.FieldMissingError;
                        pasteToSqliteOutcome.Icon = Icon.Error;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = $"剪切板上复制过来的数据有字段缺失,缺失的字段为{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}";
                        return pasteToSqliteOutcome;
                    }

                    dBOperator.ResetOnlyColumnNamesTable(withYearAndSeasonTableName);
                    try
                    {
                        foreach (DataRow Row in dtOfPaste.Rows)
                        {
                            for (int i = 0; i < dtOfPaste.Columns.Count; i++)
                            {
                                if (Row.IsNull(i) || string.IsNullOrWhiteSpace(Row[i].ToString()))
                                {
                                    Row[i] = "0";
                                }
                            }

                            string insetSql =
                                    //$"insert into {withYearAndSeasonTableName} (组织机构代码,数据处理地,综合机关名称,期别年,期别季,单位负责人,填表人,报出日期年," +
                                    //$"报出日期月,报出日期日,[存栏头数（含未断奶小猪）01],[能繁殖的母猪02]," +
                                    //$"[生猪出栏头数03],[牛存栏头数04],[良种及改良种乳牛05],[牛出栏头数06],[羊存栏只数07],[羊出栏只数08],[家禽存栏只数09],[家禽出栏只数10],[兔存栏只数11]," +
                                    //$"[兔出栏只数12],[肉类产量13],[猪  肉14],[牛  肉15], [羊  肉16],[禽  肉17],[兔  肉18],[其  它19],[鸡鸭鹅蛋产量20]," +
                                    //$"[生牛奶产量21],[蚕茧产量22],[鸡存栏23],[鸡出栏24]) " +
                                    $"insert into {withYearAndSeasonTableName} (组织机构代码,数据处理地,综合机关名称,期别年,期别季,单位负责人,填表人,报出日期年," +
                                    $"报出日期月,报出日期日,[生猪存栏头数（含未断奶小猪）01],[能繁殖的母猪存栏头数02]," +
                                    $"[生猪出栏头数03],[牛存栏头数04],[良种及改良种乳牛存栏头数05],[牛出栏头数06],[羊存栏只数07],[羊出栏只数08],[家禽存栏只数09],[家禽出栏只数10],[兔存栏只数11]," +
                                    $"[兔出栏只数12],[肉类产量13],[猪肉产量（吨）14],[牛肉产量（吨）15], [羊肉产量（吨）16],[禽肉产量（吨）17],[兔肉产量（吨）18],[其他肉产量（吨）19],[鸡鸭鹅蛋产量（吨）20]," +
                                    $"[生牛奶产量（吨）21],[蚕茧产量（吨）22],[鸡存栏只数23],[鸡出栏只数24]) " +
                                $"values('{Row["组织机构代码"].ToString()}', '{(string)Row["数据处理地"]}', '{Row["综合机关名称"]}','{Row["期别(年)"]}','{Row["期别(季)"]}','{Row["单位负责人"]}'," +
                                $"'{Row["填表人"]}','{Row["报出日期(年)"]}','{Row["报出日期(月)"]}','{Row["报出日期(日)"]}','{Row["数量;存栏头数（含未断奶小猪）"]}','{Row["数量;其中：能繁殖的母猪"]}','{Row["数量;生猪出栏头数"]}','{Row["数量;存栏头数"]}'," +
                                $"'{Row["数量;其中：良种及改良种乳牛"]}','{Row["数量;出栏头数"]}','{Row["数量;存栏只数"].ToString()}','{Row["数量;出栏只数"]}','{Row["数量;存栏只数_1"]}'," +
                                $"'{Row["数量;出栏只数_1"]}','{Row["数量;存栏只数_2"]}','{Row["数量;出栏只数_2"]}','{Row["数量;肉类产量"]}','{Row["数量;肉类产量;（省增）猪肉"]}'," +
                                $"'{Row["数量;肉类产量;牛肉"]}','{Row["数量;肉类产量;羊肉"]}','{Row["数量;肉类产量;禽肉"]}','{Row["数量;肉类产量;兔肉"]}','{Row["数量;肉类产量;其他"]}'," +
                                $"'{Row["数量;鸡鸭鹅蛋产量"]}','{Row["数量;生牛奶产量_33"]}','{Row["数量;蚕茧产量"]}','{Row["数量;其中：鸡存栏"]}','{Row["数量;其中：鸡出栏"]}')";
                            using (SqliteCommand insertCommand = new SqliteCommand(insetSql, sqliteCon))
                            {
                                insertCommand.ExecuteNonQuery();
                            }
                            processedRows++;
                            percentage = (int)((double)processedRows / totalRows * 100);
                            progress.Report(percentage);
                        }

                        dBOperator.AddImportTime(sqliteCon, withYearAndSeasonTableName);
                        List<string> sqlToAddNewColumns = new List<string>();
                        sqlToAddNewColumns.Add(
                            $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 市代码 string"); //增加"市代码"列
                        sqlToAddNewColumns.Add(
                            $"UPDATE {withYearAndSeasonTableName} SET 市代码 = SUBSTR(组织机构代码, 1, 4)"); //
                        sqlToAddNewColumns.Add(
                            $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 市 STRING"); //增加"市"字段
                        sqlToAddNewColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 市 =  substr(综合机关名称,1,3)");
                        sqlToAddNewColumns.Add(
                            $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 县代码 STRING"); //增加"县代码"字段
                        sqlToAddNewColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 县代码 = substr(组织机构代码,1,6)");
                        sqlToAddNewColumns.Add(
                            $"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 乡 STRING"); //增加"乡"字段
                        sqlToAddNewColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 乡 = 综合机关名称");
                        sqlToAddNewColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 乡镇代码 STRING");
                        sqlToAddNewColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 乡镇代码 = substr(组织机构代码,1,9)");
                        sqlToAddNewColumns.Add($"ALTER TABLE {withYearAndSeasonTableName} ADD COLUMN 县 STRING");
                        sqlToAddNewColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 县 = substr(组织机构代码,1,6)");

                        for (int i = 0; i < sqlToAddNewColumns.Count; i++)
                        {
                            dBOperator.ExecuteBySql(sqlToAddNewColumns[i]);
                        }
                    }
                    catch
                        (Exception ex)
                    {
                        percentage = 100;
                        progress.Report(percentage);
                        StaticLogger.SystemError($"粘贴出错,出错的表为{withYearAndSeasonTableName}错误信息为{ex.Message}");
                        StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
                        pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
                        pasteToSqliteOutcome.FuncOutComeInfoArgs = $"{withYearAndSeasonTableName}表错误,原因是{ex.Message}";
                        return pasteToSqliteOutcome;
                    }
                }

                //pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Success;
                //pasteToSqliteOutcome.FuncOutComeInfoArgs = null;
                pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Success;
                return pasteToSqliteOutcome;
            }
        }
        catch (Exception ex)
        {
            progress.Report(100);
            StaticLogger.SystemError($"粘贴出错,错误信息为{ex.Message}");
            StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
            pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
            pasteToSqliteOutcome.FuncOutComeInfoArgs = $"出现错误,原因是{ex.Message}";
            return pasteToSqliteOutcome;
        }
    }
    internal static async Task<FuncOutCome> AppendPasteToSqlite(IProgress<int> progress)
    {


        FuncOutCome pasteToSqliteOutcome = new FuncOutCome();
        DataTable dtOfPaste = null;
        try { 
        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
        //?. 运算符会首先检查 Application.Current 是否为 null。如果不为 null，就会继续访问 .ApplicationLifetime 属性；如果为 null，则整个表达式的结果为 null，而不抛出 NullReferenceException 异常。
        {
            var clipboard = desktop.MainWindow?.Clipboard;
            var clipboardText = await clipboard.GetTextAsync();

            if (clipboard != null)
            {
                dtOfPaste = ConvertClipboardTextToDataTable(clipboardText);
                if (dtOfPaste == null)
                {
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.NullError;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = "没有复制数据,请重试";
                    pasteToSqliteOutcome.Icon = Icon.Error;
                    return pasteToSqliteOutcome;
                }
            }
            else
            {
                // await MyMessagebox.ShowAsync("没有复制数据,请重试",window);
                pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.NullError;
                pasteToSqliteOutcome.FuncOutComeInfoArgs = "没有复制数据,请重试";
                pasteToSqliteOutcome.Icon = Icon.Error;
                return pasteToSqliteOutcome;
            }
        }

        //先判断是不是要导入的数据复制过来了
        if (dtOfPaste.Columns.Contains("年") == false || dtOfPaste.Columns.Contains("季") == false)
        {
            // await MyMessagebox.ShowAsync("数据复制错了,请重试",window);
            pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.IncongruentError;
            pasteToSqliteOutcome.FuncOutComeInfoArgs = "复制数据错误,请重新复制";
            pasteToSqliteOutcome.Icon = Icon.Error;
            return pasteToSqliteOutcome;
        }

        //获取季度和年度 
        DataRow firstRow = dtOfPaste.Rows[0];
        var yearValue = firstRow["年"].ToString();
        var seasonValue = firstRow["季"].ToString();
        string tableName = null;
        if (dtOfPaste.Columns.Contains("1;现有养猪头数-期末存栏（头）"))
        {
            tableName = "A209";
        }
        else if (dtOfPaste.Columns.Contains("1;期末存栏-肉牛（头）-能繁殖母牛"))
        {
            tableName = "A210";
        }
        else if (dtOfPaste.Columns.Contains("1;期末存栏（只）-山羊（只）-能繁殖母山羊"))
        {
            tableName = "A211";
        }
        else if (dtOfPaste.Columns.Contains("1;期末存栏（只）-肉用家禽合计（只）-肉鸡（只）"))
        {
            tableName = "A212";
        }

        else
        {
            // await MyMessagebox.ShowAsync("复制的字段错误,请重试",window);
            pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.NullError;
            pasteToSqliteOutcome.FuncOutComeInfoArgs = "复制的字段错误,不是四个表中的任何一个,请重新复制";
            return pasteToSqliteOutcome;
        }

        string yearAndSeason = $"统计云{yearValue}年{ConvertIntToStringOfSeason<string>(seasonValue)}";
        string withYearAndSeasonTableName = yearAndSeason + tableName;
        //MyDBOperator dBOperator = new MyDBOperator();改用单例模式
        MyDBOperator dBOperator = MyDBOperator.DBOperatorInstance;
        //把datatable的数据导入到sqlite中
        //先看看数据库里面是否有这张表了
       bool iswithYearAndSeasonTableNameExists = dBOperator.CheckIfTableExists(withYearAndSeasonTableName);
        if (iswithYearAndSeasonTableNameExists==false)
        {
            pasteToSqliteOutcome.FuncSuccessCode=FuncOutComeCodeType.NullError;
            pasteToSqliteOutcome.FuncOutComeInfoArgs = @"数据库中还没有这张表,无法追加,请点击“粘贴”按钮!";
            return pasteToSqliteOutcome;
        }


        

        List<string> pasteColumnsNames =
            dtOfPaste.Columns.Cast<DataColumn>().Select(col => col.ColumnName).ToList();

        if (dtOfPaste != null)
        {
            DeleteNullRow(dtOfPaste, 填报时间取数列名);//这里可能要调整,报出日期改成了填报时间
        }

        //  dBOperator.ResetOnlyColumnNamesTable(withYearAndSeasonTableName);//这句要放到后面去,不然有列没行数据,报错
        int totalRows = dtOfPaste.Rows.Count;
        int processedRows = 0;
        int percentage = 0;
        using (SqliteConnection sqliteCon = new SqliteConnection($"Data Source={MyDBOperator._dbPath}"))
        {
            sqliteCon.Open();

            if (withYearAndSeasonTableName.Contains("A209"))
            {
                string[] DBNeedcolumnNames =
                [
                    "处理地编码",
                    "处理地名称",
                    "养殖场（户）编码：",
                    "养殖场（户）名称：",
                    "填报时间",
                    "年",
                    "季",
                    "省（区、市）",
                    "市（地、州、盟）",
                    "调查村地址（县）",
                    "乡村",
                    "调查村地址（村）",
                    "调查村编码",
                    "养殖户（单位）类型",
                    "1;现有养猪头数-期末存栏（头）",
                    "1;现有养猪头数-期末存栏（头）-25公斤以下仔猪",
                    "1;现有养猪头数-期末存栏（头）-待育肥猪",
                    "1;现有养猪头数-期末存栏（头）-待育肥猪-50公斤以上",
                    "1;现有养猪头数-期末存栏（头）-种猪",
                    "1;现有养猪头数-期末存栏（头）-种猪-能繁殖母猪",
                    "1;期内增加数量（头）",
                    "1;期内增加数量（头）-自繁",
                    "1;期内增加数量（头）-购进",
                    "1;期内减少数量（头）",
                    "1;期内减少数量（头）-自宰肥猪数量（头）",
                    "1;期内减少数量（头）-出售肥猪-数量（头）",
                    "1;期内减少数量（头）-出售肥猪-金额（元）",
                    "1;期内减少数量（头）-出售肥猪-重量（公斤）",
                    "1;期内减少数量（头）-其他原因减少数量（头）",
                    "1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-数量（头）",
                    "1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-金额（元）",
                    "1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-重量（公斤）",
                    "单位负责人",
                    "填表人",
                    "报出日期"
                ];
                var pasteLostColumnsNames = DBNeedcolumnNames.Except(pasteColumnsNames); //找出数据库里要有,但是excel里没有的字段
                if (pasteLostColumnsNames.Count() > 0)
                {
                    string StrPasteLostColumnsNames = null;
                    foreach (var item in pasteLostColumnsNames)
                    {
                        StrPasteLostColumnsNames += $"“{item.ToString()}”、";
                    }

                    // await MyMessagebox.ShowAsync($"{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}缺失,请重新从平台下载数据后再次导入!",window);
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.FieldMissingError;
                    pasteToSqliteOutcome.Icon = Icon.Error;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = $"剪切板上复制过来的数据有字段缺失,缺失字段为{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}";
                    return pasteToSqliteOutcome;
                }

                
                try
                {
                    foreach (DataRow Row in dtOfPaste.Rows)
                    {
                        for (int i = 0; i < dtOfPaste.Columns.Count; i++)
                        {
                            if (Row.IsNull(i) || string.IsNullOrWhiteSpace(Row[i].ToString()))
                            {
                                Row[i] = "0";
                            }
                        }
                        //先判断一下数据库里是否有此数据了,通过户编码来判断
                       int count = dBOperator.CountOfParameterInAssignedColumn(Row.Field<string>("养殖场（户）编码："), "户编码",withYearAndSeasonTableName);
                        if (count > 0)
                        {
                            pasteToSqliteOutcome.FuncOutComeInfoArgs += $"户编码为{Row.Field<string>("养殖场（户）编码：")}的养殖户已经存在数据库中了,本条没有追加" + Environment.NewLine;
                            pasteToSqliteOutcome.Icon = Icon.Warning;
                        }
                        else
                        {




                            string insetSql =
                                    //$"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,养殖户单位类型,村,单位负责人,填表人,报出日期年," +
                                    //$"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,[期末存栏合计01],[25公斤以下仔猪02]," +
                                    //$"[待育肥猪03],[50公斤以上04],[种猪05],[能繁殖母猪06],[当季增加头数07],[自繁08],[购进09],[当季减少头数10],[自宰肥猪头数11]," +
                                    //$"[出售肥猪头数（不包括出售待育肥猪）12],[出售肥猪金额13],[出售肥猪重量14],[其它原因减少（包括死亡、疫病捕杀）15], " +
                                    //$"[出售25公斤以下仔猪头数16],[出售25公斤以下仔猪金额17],[出售25公斤以下仔猪重量18]) " +
                                    $"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,养殖户单位类型,村,单位负责人,填表人,报出日期年," +
                                    $"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,[期末存栏合计01],[25公斤以下仔猪存栏数02]," +
                                    $"[待育肥猪存栏数03],[50公斤以上待育肥猪存栏数04],[种猪存栏数05],[能繁殖母猪存栏数06],[当季增加头数07],[自繁头数08],[购进头数09],[当季减少头数10],[自宰肥猪头数11]," +
                                    $"[出售肥猪头数（不包括出售待育肥猪）12],[出售肥猪金额（元）13],[出售肥猪重量（公斤）14],[其它原因减少（包括死亡、疫病捕杀）15], " +
                                    $"[出售25公斤以下仔猪头数16],[出售25公斤以下仔猪金额（元）17],[出售25公斤以下仔猪重量（公斤）18]) " +
                                $"values('{Row["调查村编码"].ToString()}', '{(string)Row["调查村编码"]}', '{Row["养殖户（单位）类型"].ToString()}','{Row["调查村地址（村）"]}','{Row["单位负责人"]}','{Row["填表人"]}'" +
                                $",'{Row["年"]}','{Row[$"{填报时间取数列名}"].ToString().Substring(5, 2)}','{Row[$"{填报时间取数列名}"].ToString().Substring(8, 2)}','{Row["省（区、市）"]}','{Row["市（地、州、盟）"]}','{Row["调查村地址（县）"]}','{Row["乡村"]}'," +
                                $"'{Row["年"]}','{Row["季"]}','{Row["养殖场（户）编码："]}','{Row["养殖场（户）名称："]}','{Row["1;现有养猪头数-期末存栏（头）"]}','{Row["1;现有养猪头数-期末存栏（头）-25公斤以下仔猪"]}'," +
                                $"'{Row["1;现有养猪头数-期末存栏（头）-待育肥猪"]}','{Row["1;现有养猪头数-期末存栏（头）-待育肥猪-50公斤以上"]}','{Row["1;现有养猪头数-期末存栏（头）-种猪"]}','{Row["1;现有养猪头数-期末存栏（头）-种猪-能繁殖母猪"]}'," +
                                $"'{Row["1;期内增加数量（头）"]}','{Row["1;期内增加数量（头）-自繁"]}','{Row["1;期内增加数量（头）-购进"]}','{Row["1;期内减少数量（头）"]}','{Row["1;期内减少数量（头）-自宰肥猪数量（头）"]}'," +
                                $"'{Row["1;期内减少数量（头）-出售肥猪-数量（头）"]}','{Row["1;期内减少数量（头）-出售肥猪-金额（元）"]}','{Row["1;期内减少数量（头）-出售肥猪-重量（公斤）"]}','{Row["1;期内减少数量（头）-其他原因减少数量（头）"]}','{Row["1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-数量（头）"]}'," +
                                $"'{Row["1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-金额（元）"]}','{Row["1;期内减少数量（头）-其他原因减少数量（头）-出售25公斤以下仔猪-重量（公斤）"]}' )";


                            using (SqliteCommand insertCommand = new SqliteCommand(insetSql, sqliteCon))
                            {
                                insertCommand.ExecuteNonQuery();
                            }
                        }
                        processedRows++;
                        percentage = (int)((double)processedRows / totalRows * 100);
                        progress.Report(percentage);
                    }

                    dBOperator.AddImportTime(sqliteCon, withYearAndSeasonTableName);
                    //增加字段
                    List<string> sqlToAddColumns = new List<string>() {

                      
                        $"UPDATE {withYearAndSeasonTableName} SET 当季出栏数 = [自宰肥猪头数11] + [出售肥猪头数（不包括出售待育肥猪）12]",
                       
                        $"UPDATE {withYearAndSeasonTableName} SET 乡镇代码 = substr(户编码,1,9)",
                    
                        $"UPDATE {withYearAndSeasonTableName} SET 县代码 = substr(户编码,1,6)",
                       
                        $"UPDATE {withYearAndSeasonTableName} SET 市代码 = substr(户编码,1,4)",
                     
                        $"UPDATE {withYearAndSeasonTableName} SET 数据处理县代码 = substr(数据处理地,1,6)",
                    };

                    for (int i = 0; i < sqlToAddColumns.Count; i++)
                    {
                        dBOperator.ExecuteBySql(sqlToAddColumns[i]);
                    }
                }
                catch (Exception ex)
                {
                    percentage = 100;
                    progress.Report(percentage);
                    StaticLogger.SystemError($"粘贴出错,出错的表为{withYearAndSeasonTableName}错误信息为{ex.Message}");
                    StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = $"{withYearAndSeasonTableName}表错误,原因是{ex.Message}";
                    return pasteToSqliteOutcome;
                }
            }
            else if (withYearAndSeasonTableName.Contains("A210"))
            {
                string[] DBNeedcolumnNames =
                [
                    "处理地编码",
                    "处理地名称",
                    "养殖场（户）编码：",
                    "养殖场（户）名称：",
                    "填报时间",
                    "年",
                    "季",
                    "省",
                    "市（地、州、盟）",
                    "县",
                    "乡（镇）",
                    "调查村地址（村）",
                    "调查村编码",
                    "养殖户（单位）类型",
                    "1;期末存栏",
                    "1;期末存栏-肉牛（头）",
                    "1;期末存栏-肉牛（头）-能繁殖母牛",
                    "1;期末存栏-奶牛（头）",
                    "1;期末存栏-奶牛（头）-在产专用奶牛（头）",
                    "1;期内增加数量（头）",
                    "1;期内增加数量（头）-自繁（头）",
                    "1;期内增加数量（头）-自繁（头）-肉牛（头）",
                    "1;期内增加数量（头）-自繁（头）-奶牛（头）",
                    "1;期内增加数量（头）-购进（头）",
                    "1;期内增加数量（头）-购进（头）-肉牛（头）",
                    "1;期内增加数量（头）-购进（头）-奶牛（头）",
                    "1;期内减少数量（头）",
                    "1;期内减少数量（头）-自宰肉牛（头）",
                    "1;期内减少数量（头）-出售肉牛-数量（头）",
                    "1;期内减少数量（头）-出售肉牛-金额（元）",
                    "1;期内减少数量（头）-出售肉牛-重量（公斤）",
                    "1;期内减少数量（头）-生牛奶产量（公斤）",
                    "单位负责人",
                    "填表人",
                    "报出日期"
                ];
                var pasteLostColumnsNames = DBNeedcolumnNames.Except(pasteColumnsNames); //找出数据库里要有,但是excel里没有的字段
                if (pasteLostColumnsNames.Count() > 0)
                {
                    string StrPasteLostColumnsNames = null;
                    foreach (var item in pasteLostColumnsNames)
                    {
                        StrPasteLostColumnsNames += $"“{item.ToString()}”、";
                    }

                    //await MyMessagebox.ShowAsync(
                    //    $"{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}缺失,请重新从平台下载数据后再次导入!",window);
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.FieldMissingError;
                    pasteToSqliteOutcome.Icon = Icon.Error;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = $"剪切板上复制过来的数据有字段缺失,缺失字段为{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}";
                    return pasteToSqliteOutcome;

                }
                
                try
                {
                    foreach (DataRow Row in dtOfPaste.Rows)
                    {
                        for (int i = 0; i < dtOfPaste.Columns.Count; i++)
                        {
                            if (Row.IsNull(i) || string.IsNullOrWhiteSpace(Row[i].ToString()))
                            {
                                Row[i] = "0";
                            }
                        }
                        //先判断一下数据库里是否有此数据了,通过户编码来判断
                        int count = dBOperator.CountOfParameterInAssignedColumn(Row.Field<string>("养殖场（户）编码："), "户编码", withYearAndSeasonTableName);
                        if (count > 0)
                        {
                            pasteToSqliteOutcome.FuncOutComeInfoArgs += $"户编码为{Row.Field<string>("养殖场（户）编码：")}的养殖户已经存在数据库中了,本条没有追加"+Environment.NewLine;
                            pasteToSqliteOutcome.Icon = Icon.Warning;
                        }
                        else
                        {
                            string insetSql =
                                //$"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                //$"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏头数01],[肉牛02]," +
                                //$"[能繁殖母牛03],[奶牛04],[在产奶牛05],[当季增加头数06],[自繁07],[肉牛08],[奶牛09],[购进10],[肉牛11]," +
                                //$"[奶牛12],[期内减少头数13],[自宰肉牛数量14],[出售肉牛数量15], " +
                                //$"[出售肉牛金额16],[出售肉牛重量17],[当季生牛奶产量18]) " +
                                $"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                $"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏头数01],[肉牛存栏数02]," +
                                $"[能繁殖母牛存栏数03],[奶牛存栏数04],[在产奶牛存栏数05],[当季增加头数06],[自繁头数07],[自繁肉牛头数08],[自繁奶牛头数09],[购进头数10],[购进肉牛头数11]," +
                                $"[购进奶牛头数12],[期内减少头数13],[自宰肉牛数量14],[出售肉牛数量15], " +
                                $"[出售肉牛金额（元）16],[出售肉牛重量（公斤）17],[当季生牛奶产量（公斤）18]) " +
                            $"values('{Row["调查村编码"].ToString()}', '{(string)Row["调查村编码"]}','{Row["调查村地址（村）"]}','{Row["单位负责人"]}','{Row["填表人"]}'" +
                            $",'{Row["年"]}','{Row[$"{填报时间取数列名}"].ToString().Substring(5, 2)}','{Row[$"{填报时间取数列名}"].ToString().Substring(8, 2)}','{Row["省"]}','{Row["市（地、州、盟）"]}','{Row["县"]}','{Row["乡（镇）"]}'," +
                            $"'{Row["年"]}','{Row["季"]}','{Row["养殖场（户）编码："]}','{Row["养殖场（户）名称："]}','{Row["养殖户（单位）类型"]}','{Row["1;期末存栏"]}','{Row["1;期末存栏-肉牛（头）"]}'," +
                            $"'{Row["1;期末存栏-肉牛（头）-能繁殖母牛"]}','{Row["1;期末存栏-奶牛（头）"]}','{Row["1;期末存栏-奶牛（头）-在产专用奶牛（头）"]}','{Row["1;期内增加数量（头）"]}'," +
                            $"'{Row["1;期内增加数量（头）-自繁（头）"]}','{Row["1;期内增加数量（头）-自繁（头）-肉牛（头）"]}','{Row["1;期内增加数量（头）-自繁（头）-奶牛（头）"]}','{Row["1;期内增加数量（头）-购进（头）"]}','{Row["1;期内增加数量（头）-购进（头）-肉牛（头）"]}'," +
                            $"'{Row["1;期内增加数量（头）-购进（头）-奶牛（头）"]}','{Row["1;期内减少数量（头）"]}','{Row["1;期内减少数量（头）-自宰肉牛（头）"]}','{Row["1;期内减少数量（头）-出售肉牛-数量（头）"]}','{Row["1;期内减少数量（头）-出售肉牛-金额（元）"]}'," +
                            $"'{Row["1;期内减少数量（头）-出售肉牛-重量（公斤）"]}','{Row["1;期内减少数量（头）-生牛奶产量（公斤）"]}' )";
                            using (SqliteCommand insertCommand = new SqliteCommand(insetSql, sqliteCon))
                            {
                                insertCommand.ExecuteNonQuery();
                            }
                        }
                        processedRows++;
                        percentage = (int)((double)processedRows / totalRows * 100);
                        progress.Report(percentage);
                    }

                    dBOperator.AddImportTime(sqliteCon, withYearAndSeasonTableName);
                    List<string> ListSqlToAddColumns =
                    [
                   
                        $"UPDATE {withYearAndSeasonTableName} SET 当季出栏数 = [自宰肉牛数量14] + [出售肉牛数量15]",
                    
                        $"UPDATE {withYearAndSeasonTableName} SET 乡镇代码 = substr(户编码,1,9)",
                      
                        $"UPDATE {withYearAndSeasonTableName} SET 县代码 = substr(户编码,1,6)",
                       
                        $"UPDATE {withYearAndSeasonTableName} SET 市代码 = substr(户编码,1,4)",
                       
                        $"UPDATE {withYearAndSeasonTableName} SET 数据处理县代码 = substr(数据处理地,1,6)",
                    ];
                    for (int i = 0; i < ListSqlToAddColumns.Count; i++)
                    {
                        dBOperator.ExecuteBySql(ListSqlToAddColumns[i]);
                    }
                }
                catch (Exception ex)
                {
                    percentage = 100;
                    progress.Report(percentage);
                    StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = $"{withYearAndSeasonTableName}表错误,原因是{ex.Message}";
                    return pasteToSqliteOutcome;
                }
            }
            else if (withYearAndSeasonTableName.Contains("A211"))
            {
                string[] DBNeedcolumnNames =
                [
                    "处理地编码",
                    "处理地名称",
                    "养殖场（户）编码：",
                    "养殖场（户）名称：",
                    "填报时间",
                    "年",
                    "季",
                    "省（区、市）",
                    "市（地、州、盟）",
                    "县（区、市）",
                    "乡（镇）",
                    "调查村地址（村）",
                    "调查村编码",
                    "养殖户（单位）类型",
                    "1;期末存栏（只）",
                    "1;期末存栏（只）-山羊（只）",
                    "1;期末存栏（只）-山羊（只）-能繁殖母山羊",
                    "1;期末存栏（只）-绵羊（只）",
                    "1;期末存栏（只）-绵羊（只）-能繁殖母绵羊",
                    "1;期内增加数量（只）",
                    "1;期内增加数量（只）-自繁（只）",
                    "1;期内增加数量（只）-自繁（只）-山羊（只）",
                    "1;期内增加数量（只）-自繁（只）-绵羊（只）",
                    "1;期内增加数量（只）-购进（只）",
                    "1;期内增加数量（只）-购进（只）-山羊（只）",
                    "1;期内增加数量（只）-购进（只）-绵羊（只）",
                    "1;期内减少数量（只）",
                    "1;期内减少数量（只）-自宰羊数量（只）",
                    "1;期内减少数量（只）-出售羊-数量（只）",
                    "1;期内减少数量（只）-出售羊-金额（元）",
                    "1;期内减少数量（只）-出售羊-重量（公斤）",
                    "1;绵羊毛产量（公斤）",
                    "1;山羊绒产量（公斤）",
                    "单位负责人",
                    "填表人",
                    "报出日期"
                ];
                var pasteLostColumnsNames = DBNeedcolumnNames.Except(pasteColumnsNames); //找出数据库里要有,但是excel里没有的字段
                if (pasteLostColumnsNames.Count() > 0)
                {
                    string StrPasteLostColumnsNames = null;
                    foreach (var item in pasteLostColumnsNames)
                    {
                        StrPasteLostColumnsNames += $"“{item.ToString()}”、";
                    }

                    //await MyMessagebox.ShowAsync(
                    //    $"{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}缺失,请重新从平台下载数据后再次导入!",window);
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.FieldMissingError;
                    pasteToSqliteOutcome.Icon = Icon.Error;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = $"剪切板上复制过来的数据有字段缺失,缺失的字段为{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}";
                    return pasteToSqliteOutcome;
                }

              
                try
                {
                    foreach (DataRow Row in dtOfPaste.Rows)
                    {
                        for (int i = 0; i < dtOfPaste.Columns.Count; i++)
                        {
                            if (Row.IsNull(i) || string.IsNullOrWhiteSpace(Row[i].ToString()))
                            {
                                Row[i] = "0";
                            }
                        }
                        //先判断一下数据库里是否有此数据了,通过户编码来判断
                        int count = dBOperator.CountOfParameterInAssignedColumn(Row.Field<string>("养殖场（户）编码："), "户编码", withYearAndSeasonTableName);
                        if (count > 0)
                        {
                            pasteToSqliteOutcome.FuncOutComeInfoArgs += $"户编码为{Row.Field<string>("养殖场（户）编码：")}的养殖户已经存在数据库中了,本条没有追加" + Environment.NewLine;
                            pasteToSqliteOutcome.Icon = Icon.Warning;
                        }
                        else
                        {
                            string insetSql =
                                //$"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                //$"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏只数01],[山   羊02]," +
                                //$"[能繁殖母山羊03],[绵(湖)羊04],[能繁殖母绵羊05],[期内增加只数06],[自繁07],[山   羊08],[绵(湖)羊09],[购进10],[山   羊11]," +
                                //$"[绵(湖)羊12],[期内减少只数13],[自宰羊数量14],[出售羊数量15], " +
                                //$"[出售羊金额16],[出售羊重量17],[当季绵羊毛产量18],[当季山羊绒产量19]) " +
                                $"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                $"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏只数01],[山羊存栏只数02]," +
                                $"[能繁殖母山羊存栏只数03],[绵(湖)羊存栏只数04],[能繁殖母绵羊存栏只数05],[期内增加只数06],[自繁只数07],[山羊自繁只数08],[绵(湖)羊自繁只数09],[购进只数10],[山羊购进只数11]," +
                                $"[绵(湖)羊购进只数12],[期内减少只数13],[自宰羊数量14],[出售羊数量15], " +
                                $"[出售羊金额（元）16],[出售羊重量（公斤）17],[当季绵羊毛产量（公斤）18],[当季山羊绒产量（公斤）19]) " +
                            $"values('{Row["调查村编码"].ToString()}', '{(string)Row["调查村编码"]}','{Row["调查村地址（村）"]}','{Row["单位负责人"]}','{Row["填表人"]}'" +
                            $",'{Row["年"]}','{Row[$"{填报时间取数列名}"].ToString().Substring(5, 2)}','{Row[$"{填报时间取数列名}"].ToString().Substring(8, 2)}','{Row["省（区、市）"]}','{Row["市（地、州、盟）"]}','{Row["县（区、市）"]}','{Row["乡（镇）"]}'," +
                            $"'{Row["年"]}','{Row["季"]}','{Row["养殖场（户）编码："]}','{Row["养殖场（户）名称："]}','{Row["养殖户（单位）类型"]}','{Row["1;期末存栏（只）"]}','{Row["1;期末存栏（只）-山羊（只）"]}'," +
                            $"'{Row["1;期末存栏（只）-山羊（只）-能繁殖母山羊"]}','{Row["1;期末存栏（只）-绵羊（只）"]}','{Row["1;期末存栏（只）-绵羊（只）-能繁殖母绵羊"]}','{Row["1;期内增加数量（只）"]}'," +
                            $"'{Row["1;期内增加数量（只）-自繁（只）"]}','{Row["1;期内增加数量（只）-自繁（只）-山羊（只）"]}','{Row["1;期内增加数量（只）-自繁（只）-绵羊（只）"]}','{Row["1;期内增加数量（只）-购进（只）"]}','{Row["1;期内增加数量（只）-购进（只）-山羊（只）"]}'," +
                            $"'{Row["1;期内增加数量（只）-购进（只）-绵羊（只）"]}','{Row["1;期内减少数量（只）"]}','{Row["1;期内减少数量（只）-自宰羊数量（只）"]}','{Row["1;期内减少数量（只）-出售羊-数量（只）"]}','{Row["1;期内减少数量（只）-出售羊-金额（元）"]}'," +
                            $"'{Row["1;期内减少数量（只）-出售羊-重量（公斤）"]}','{Row["1;绵羊毛产量（公斤）"]}','{Row["1;山羊绒产量（公斤）"]}' )";
                            using (SqliteCommand insertCommand = new SqliteCommand(insetSql, sqliteCon))
                            {
                                insertCommand.ExecuteNonQuery();
                            }
                        }
                        processedRows++;
                        percentage = (int)((double)processedRows / totalRows * 100);
                        progress.Report(percentage);
                    }

                    dBOperator.AddImportTime(sqliteCon, withYearAndSeasonTableName);
                    List<string> ListSqlToAddColumns = new List<string>();
                    
                    ListSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季出栏数 = [自宰羊数量14] + [出售羊数量15]");
                    
                    ListSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 乡镇代码 = substr(户编码,1,9)");
                   
                    ListSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 县代码 = substr(户编码,1,6)");
                    
                    ListSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 市代码 = substr(户编码,1,4)");
                   
                    ListSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 数据处理县代码 = substr(数据处理地,1,6)");
                    for (int i = 0; i < ListSqlToAddColumns.Count; i++)
                    {
                        dBOperator.ExecuteBySql(ListSqlToAddColumns[i]);
                    }
                }
                catch (Exception ex)
                {
                    percentage = 100;
                    progress.Report(percentage);
                    StaticLogger.SystemError($"粘贴出错,出错的表为{withYearAndSeasonTableName}错误信息为{ex.Message}");
                    StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = $"{withYearAndSeasonTableName}表错误,原因是{ex.Message}";
                    return pasteToSqliteOutcome;
                }
            }
            else if (withYearAndSeasonTableName.Contains("A212"))
            {
                string[] DBNeedcolumnNames =
                [
                    "处理地编码",
                    "处理地名称",
                    "养殖场（户）编码：",
                    "养殖场（户）名称：",
                    "填报时间",
                    "年",
                    "季",
                    "省（区、市）",
                    "市（地、州、盟）",
                    "县（区、市）",
                    "乡（镇）",
                    "调查村地址（村）",
                    "调查村编码",
                    "养殖户（单位）类型",
                    "1;期末存栏（只）",
                    "1;期末存栏（只）-肉用家禽合计（只）",
                    "1;期末存栏（只）-肉用家禽合计（只）-肉鸡（只）",
                    "1;期末存栏（只）-蛋用家禽合计（只）",
                    "1;期末存栏（只）-蛋用家禽合计（只）-蛋鸡（只）",
                    "1;期内减少数量（只）",
                    "1;期内减少数量（只）-自宰家禽数量（只）",
                    "1;期内减少数量（只）-自宰家禽数量（只）-活鸡（只）",
                    "1;期内减少数量（只）-出售家禽-数量（只）",
                    "1;期内减少数量（只）-出售家禽-数量（只）-活鸡（只）",
                    "1;期内减少数量（只）-出售家禽-金额（元）",
                    "1;期内减少数量（只）-出售家禽-金额（元）-活鸡（元）",
                    "1;期内减少数量（只）-出售家禽-重量（公斤）",
                    "1;期内减少数量（只）-出售家禽-重量（公斤）-活鸡（公斤）",
                    "1;禽蛋数量（公斤）",
                    "1;禽蛋数量（公斤）-鸡蛋（公斤）",
                    "单位负责人",
                    "填表人",
                    "报出日期"
                ];


                var pasteLostColumnsNames = DBNeedcolumnNames.Except(pasteColumnsNames); //找出数据库里要有,但是excel里没有的字段
                if (pasteLostColumnsNames.Count() > 0)
                {
                    string StrPasteLostColumnsNames = null;
                    foreach (var item in pasteLostColumnsNames)
                    {
                        StrPasteLostColumnsNames += $"“{item.ToString()}”、";
                    }

                    //await MyMessagebox.ShowAsync(
                    //    $"{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}缺失,请重新从平台下载数据后再次导入!",window);
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.FieldMissingError;
                    pasteToSqliteOutcome.Icon = Icon.Error;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = $"剪切板上复制过来的数据有字段缺失,缺失的字段为{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}";
                    return pasteToSqliteOutcome;
                }

                
                try
                {
                    foreach (DataRow Row in dtOfPaste.Rows)
                    {
                        for (int i = 0; i < dtOfPaste.Columns.Count; i++)
                        {
                            if (Row.IsNull(i) || string.IsNullOrWhiteSpace(Row[i].ToString()))
                            {
                                Row[i] = "0";
                            }
                        }
                        //先判断一下数据库里是否有此数据了,通过户编码来判断
                        int count = dBOperator.CountOfParameterInAssignedColumn(Row.Field<string>("养殖场（户）编码："), "户编码", withYearAndSeasonTableName);
                        if (count > 0)
                        {
                            pasteToSqliteOutcome.FuncOutComeInfoArgs += $"户编码为{Row.Field<string>("养殖场（户）编码：")}的养殖户已经存在数据库中了,本条没有追加" + Environment.NewLine;
                            pasteToSqliteOutcome.Icon = Icon.Warning;
                        }
                        else
                        {
                            string insetSql =
                                //$"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                //$"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏只数01],[肉用02]," +
                                //$"[肉鸡03],[蛋用04],[蛋鸡05],[期内减少只数06],[自宰家禽数量07],[活鸡08],[出售家禽数量09],[活鸡10],[出售家禽金额11]," +
                                //$"[活鸡12],[出售家禽重量13],[活鸡14],[当季禽蛋产量15], [鸡蛋16]) " +
                                $"insert into {withYearAndSeasonTableName} (调查村编码,数据处理地,村,单位负责人,填表人,报出日期年," +
                                $"报出日期月,报出日期日,省,市,县,乡,期别年,期别季,户编码,户主姓名,养殖户单位类型,[期末存栏只数01],[肉用家禽存栏只数02]," +
                                $"[肉鸡存栏只数03],[蛋用家禽存栏只数04],[蛋鸡存栏只数05],[期内减少只数06],[自宰家禽数量07],[自宰活鸡数量08],[出售家禽数量09],[出售活鸡数量10],[出售家禽金额（元）11]," +
                                $"[出售活鸡金额（元）12],[出售家禽重量（公斤）13],[出售活鸡重量（公斤）14],[当季禽蛋产量（公斤）15], [鸡蛋产量（公斤）16]) " +
                            $"values('{Row["调查村编码"].ToString()}', '{(string)Row["调查村编码"]}','{Row["调查村地址（村）"]}','{Row["单位负责人"]}','{Row["填表人"]}'" +
                            $",'{Row["年"]}','{Row[$"{填报时间取数列名}"].ToString().Substring(5, 2)}','{Row[$"{填报时间取数列名}"].ToString().Substring(8, 2)}','{Row["省（区、市）"]}','{Row["市（地、州、盟）"]}','{Row["县（区、市）"]}','{Row["乡（镇）"]}'," +
                            $"'{Row["年"]}','{Row["季"]}','{Row["养殖场（户）编码："]}','{Row["养殖场（户）名称："]}','{Row["养殖户（单位）类型"]}','{Row["1;期末存栏（只）"]}','{Row["1;期末存栏（只）-肉用家禽合计（只）"]}'," +
                            $"'{Row["1;期末存栏（只）-肉用家禽合计（只）-肉鸡（只）"]}','{Row["1;期末存栏（只）-蛋用家禽合计（只）"]}','{Row["1;期末存栏（只）-蛋用家禽合计（只）-蛋鸡（只）"]}','{Row["1;期内减少数量（只）"]}'," +
                            $"'{Row["1;期内减少数量（只）-自宰家禽数量（只）"]}','{Row["1;期内减少数量（只）-自宰家禽数量（只）-活鸡（只）"]}','{Row["1;期内减少数量（只）-出售家禽-数量（只）"]}','{Row["1;期内减少数量（只）-出售家禽-数量（只）-活鸡（只）"]}','{Row["1;期内减少数量（只）-出售家禽-金额（元）"]}'," +
                            $"'{Row["1;期内减少数量（只）-出售家禽-金额（元）-活鸡（元）"]}','{Row["1;期内减少数量（只）-出售家禽-重量（公斤）"]}','{Row["1;期内减少数量（只）-出售家禽-重量（公斤）-活鸡（公斤）"]}','{Row["1;禽蛋数量（公斤）"]}','{Row["1;禽蛋数量（公斤）-鸡蛋（公斤）"]}'" +
                            $" )";
                            using (SqliteCommand insertCommand = new SqliteCommand(insetSql, sqliteCon))
                            {
                                insertCommand.ExecuteNonQuery();
                            }
                        }
                        processedRows++;
                        percentage = (int)((double)processedRows / totalRows * 100);
                        progress.Report(percentage);
                    }

                    dBOperator.AddImportTime(sqliteCon, withYearAndSeasonTableName);
                    List<string> listSqlToAddColumns = new List<string>();
             
                    listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季家禽出栏数 = [自宰家禽数量07] + [出售家禽数量09]");
                    
                    //listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季鸡出栏数 = [活鸡08] + [活鸡10]");
                    listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季鸡出栏数 = [自宰活鸡数量08] + [出售活鸡数量10]");
                    
                    listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 乡镇代码 = substr(户编码,1,9)");
                
                    listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 县代码 = substr(户编码,1,6)");
              
                    listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 市代码 = substr(户编码,1,4)");
                
                    // listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季鸡存栏数 = [肉鸡03]+[蛋鸡05]");
                    listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 当季鸡存栏数 = [肉鸡存栏只数03]+[蛋鸡存栏只数05]");
               
                    listSqlToAddColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 数据处理县代码 = substr(数据处理地,1,6)");
                    for (int i = 0; i < listSqlToAddColumns.Count; i++)
                    {
                        dBOperator.ExecuteBySql(listSqlToAddColumns[i]);
                    }
                }
                catch (Exception ex)
                {
                    percentage = 100;
                    progress.Report(percentage);
                    StaticLogger.SystemError($"粘贴出错,出错的表为{withYearAndSeasonTableName}错误信息为{ex.Message}");
                    StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = $"{withYearAndSeasonTableName}表错误,原因是{ex.Message}";
                    return pasteToSqliteOutcome;
                }
            }
            else if (withYearAndSeasonTableName.Contains("A406"))
            {
                string[] DBNeedcolumnNames = new string[]
                {
                        "组织机构代码", "数据处理地", "综合机关名称", "期别(年)", "期别(季)", "单位负责人", "填表人", "报出日期(年)", "报出日期(月)", "报出日期(日)",
                        "数量;存栏头数（含未断奶小猪）", "数量;其中：能繁殖的母猪", "数量;生猪出栏头数", "数量;存栏头数", "数量;其中：良种及改良种乳牛", "数量;出栏头数",
                        "数量;存栏只数", "数量;出栏只数", "数量;存栏只数_1", "数量;出栏只数_1", "数量;存栏只数_2", "数量;出栏只数_2", "数量;肉类产量",
                        "数量;肉类产量;（省增）猪肉",
                        "数量;肉类产量;牛肉", "数量;肉类产量;羊肉", "数量;肉类产量;禽肉", "数量;肉类产量;兔肉", "数量;肉类产量;其他", "数量;鸡鸭鹅蛋产量",
                        "数量;生牛奶产量_33",
                        "数量;蚕茧产量", "数量;其中：鸡存栏", "数量;其中：鸡出栏"
                };

                var pasteLostColumnsNames = DBNeedcolumnNames.Except(pasteColumnsNames); //找出数据库里要有,但是excel里没有的字段
                if (pasteLostColumnsNames.Count() > 0)
                {
                    string StrPasteLostColumnsNames = null;
                    foreach (var item in pasteLostColumnsNames)
                    {
                        StrPasteLostColumnsNames += $"“{item.ToString()}”、";
                    }

                    //await MyMessagebox.ShowAsync(
                    //    $"{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}缺失,请重新从平台下载数据后再次导入!",window);
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.FieldMissingError;
                    pasteToSqliteOutcome.Icon = Icon.Error;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = $"剪切板上复制过来的数据有字段缺失,缺失的字段为{withYearAndSeasonTableName}的{StrPasteLostColumnsNames.Substring(0, StrPasteLostColumnsNames.Length - 1)}";
                    return pasteToSqliteOutcome;
                }

           
                try
                {
                    foreach (DataRow Row in dtOfPaste.Rows)
                    {
                        for (int i = 0; i < dtOfPaste.Columns.Count; i++)
                        {
                            if (Row.IsNull(i) || string.IsNullOrWhiteSpace(Row[i].ToString()))
                            {
                                Row[i] = "0";
                            }
                        }
                        //先判断一下数据库里是否有此数据了,通过户编码来判断
                        int count = dBOperator.CountOfParameterInAssignedColumn(Row.Field<string>("养殖场（户）编码："), "户编码", withYearAndSeasonTableName);
                        if (count > 0)
                        {
                            pasteToSqliteOutcome.FuncOutComeInfoArgs += $"户编码为{Row.Field<string>("养殖场（户）编码：")}的养殖户已经存在数据库中了,本条没有追加" + Environment.NewLine;
                            pasteToSqliteOutcome.Icon = Icon.Warning;
                        }
                        else
                        {
                            string insetSql =
                                //$"insert into {withYearAndSeasonTableName} (组织机构代码,数据处理地,综合机关名称,期别年,期别季,单位负责人,填表人,报出日期年," +
                                //$"报出日期月,报出日期日,[存栏头数（含未断奶小猪）01],[能繁殖的母猪02]," +
                                //$"[生猪出栏头数03],[牛存栏头数04],[良种及改良种乳牛05],[牛出栏头数06],[羊存栏只数07],[羊出栏只数08],[家禽存栏只数09],[家禽出栏只数10],[兔存栏只数11]," +
                                //$"[兔出栏只数12],[肉类产量13],[猪  肉14],[牛  肉15], [羊  肉16],[禽  肉17],[兔  肉18],[其  它19],[鸡鸭鹅蛋产量20]," +
                                //$"[生牛奶产量21],[蚕茧产量22],[鸡存栏23],[鸡出栏24]) " +
                                $"insert into {withYearAndSeasonTableName} (组织机构代码,数据处理地,综合机关名称,期别年,期别季,单位负责人,填表人,报出日期年," +
                                $"报出日期月,报出日期日,[生猪存栏头数（含未断奶小猪）01],[能繁殖的母猪存栏头数02]," +
                                $"[生猪出栏头数03],[牛存栏头数04],[良种及改良种乳牛存栏头数05],[牛出栏头数06],[羊存栏只数07],[羊出栏只数08],[家禽存栏只数09],[家禽出栏只数10],[兔存栏只数11]," +
                                $"[兔出栏只数12],[肉类产量13],[猪肉产量（吨）14],[牛肉产量（吨）15], [羊肉产量（吨）16],[禽肉产量（吨）17],[兔肉产量（吨）18],[其他肉产量（吨）19],[鸡鸭鹅蛋产量（吨）20]," +
                                $"[生牛奶产量（吨）21],[蚕茧产量（吨）22],[鸡存栏只数23],[鸡出栏只数24]) " +
                            $"values('{Row["组织机构代码"].ToString()}', '{(string)Row["数据处理地"]}', '{Row["综合机关名称"]}','{Row["期别(年)"]}','{Row["期别(季)"]}','{Row["单位负责人"]}'," +
                            $"'{Row["填表人"]}','{Row["报出日期(年)"]}','{Row["报出日期(月)"]}','{Row["报出日期(日)"]}','{Row["数量;存栏头数（含未断奶小猪）"]}','{Row["数量;其中：能繁殖的母猪"]}','{Row["数量;生猪出栏头数"]}','{Row["数量;存栏头数"]}'," +
                            $"'{Row["数量;其中：良种及改良种乳牛"]}','{Row["数量;出栏头数"]}','{Row["数量;存栏只数"].ToString()}','{Row["数量;出栏只数"]}','{Row["数量;存栏只数_1"]}'," +
                            $"'{Row["数量;出栏只数_1"]}','{Row["数量;存栏只数_2"]}','{Row["数量;出栏只数_2"]}','{Row["数量;肉类产量"]}','{Row["数量;肉类产量;（省增）猪肉"]}'," +
                            $"'{Row["数量;肉类产量;牛肉"]}','{Row["数量;肉类产量;羊肉"]}','{Row["数量;肉类产量;禽肉"]}','{Row["数量;肉类产量;兔肉"]}','{Row["数量;肉类产量;其他"]}'," +
                            $"'{Row["数量;鸡鸭鹅蛋产量"]}','{Row["数量;生牛奶产量_33"]}','{Row["数量;蚕茧产量"]}','{Row["数量;其中：鸡存栏"]}','{Row["数量;其中：鸡出栏"]}')";
                            using (SqliteCommand insertCommand = new SqliteCommand(insetSql, sqliteCon))
                            {
                                insertCommand.ExecuteNonQuery();
                            }
                        }
                        processedRows++;
                        percentage = (int)((double)processedRows / totalRows * 100);
                        progress.Report(percentage);
                    }

                    dBOperator.AddImportTime(sqliteCon, withYearAndSeasonTableName);
                    List<string> sqlToAddNewColumns = new List<string>();
                    
                    sqlToAddNewColumns.Add(
                        $"UPDATE {withYearAndSeasonTableName} SET 市代码 = SUBSTR(组织机构代码, 1, 4)"); //
                
                    sqlToAddNewColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 市 =  substr(综合机关名称,1,3)");
                    
                    sqlToAddNewColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 县代码 = substr(组织机构代码,1,6)");
                   
                    sqlToAddNewColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 乡 = 综合机关名称");
                    
                    sqlToAddNewColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 乡镇代码 = substr(组织机构代码,1,9)");
                  
                    sqlToAddNewColumns.Add($"UPDATE {withYearAndSeasonTableName} SET 县 = substr(组织机构代码,1,6)");

                    for (int i = 0; i < sqlToAddNewColumns.Count; i++)
                    {
                        dBOperator.ExecuteBySql(sqlToAddNewColumns[i]);
                    }
                }
                catch
                    (Exception ex)
                {
                    percentage = 100;
                    progress.Report(percentage);
                    StaticLogger.SystemError($"粘贴出错,出错的表为{withYearAndSeasonTableName}错误信息为{ex.Message}");
                    StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
                    pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
                    pasteToSqliteOutcome.FuncOutComeInfoArgs = $"{withYearAndSeasonTableName}表错误,原因是{ex.Message}";
                    return pasteToSqliteOutcome;
                }
            }

            pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Success;
            return pasteToSqliteOutcome;
        }
        }
        catch (Exception ex)
        {
            progress.Report(100);
            StaticLogger.SystemError($"追加粘贴出错,错误信息为{ex.Message}");
            StaticLogger.SystemError($"堆栈为{ex.StackTrace},{Environment.NewLine}对象为{ex.Source},{Environment.NewLine}方法为{ex.TargetSite}");
            pasteToSqliteOutcome.FuncSuccessCode = FuncOutComeCodeType.Error;
            pasteToSqliteOutcome.FuncOutComeInfoArgs = $"出现错误,原因是{ex.Message}";
            return pasteToSqliteOutcome;
        }
    }
}